{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🧠🤖 Deep Agents with LangGraph\n",
    "\n",
    "Using an LLM to call tools in a loop is the simplest form of an agent. This architecture, however, can yield agents that are \"shallow\" and fail to plan and act over longer, more complex tasks. Applications like \"Deep Research\", \"Manus\", and \"Claude Code\" have gotten around this limitation by implementing a combination of four things:\n",
    "\n",
    "- **Planning tool** - helps agents structure complex tasks\n",
    "- **Sub agents** - specialized agents for specific tasks  \n",
    "- **File system** - persistent workspace for intermediate results\n",
    "- **Detailed prompt** - comprehensive instructions for deep reasoning\n",
    "\n",
    "This notebook demonstrates the `deepagents` library which implements these patterns in a general purpose way, allowing you to easily create Deep Agents for your applications.\n",
    "\n",
    "## What Makes an Agent \"Deep\"?\n",
    "\n",
    "Deep agents differ from simple tool-calling agents in several key ways:\n",
    "\n",
    "1. **Planning Capability** - Can break down complex tasks into subtasks\n",
    "2. **Context Quarantine** - Uses sub-agents to avoid context pollution\n",
    "3. **Persistent Workspace** - Maintains state across multiple interactions\n",
    "4. **Specialized Instructions** - Detailed prompts for specific domains\n",
    "\n",
    "In this exercise, we'll build a deep research agent that can conduct thorough investigations and produce comprehensive reports."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation and Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install required packages\n",
    "!uv pip install -qU deepagents tavily-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Literal\n",
    "from tavily import TavilyClient\n",
    "from deepagents import create_deep_agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set up API keys - you'll need these for the example to work\n",
    "# Get Tavily API key from: https://app.tavily.com/\n",
    "# Get Anthropic API key from: https://console.anthropic.com/\n",
    "\n",
    "# os.environ[\"TAVILY_API_KEY\"] = \"your-tavily-api-key-here\"\n",
    "# os.environ[\"ANTHROPIC_API_KEY\"] = \"your-anthropic-api-key-here\"\n",
    "\n",
    "# Alternatively, load from a .env file\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tool Definitions\n",
    "\n",
    "First, we'll define the tools our research agent will use. For this example, we'll use Tavily's web search API to gather information from the internet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def internet_search(\n",
    "    query: str,\n",
    "    max_results: int = 5,\n",
    "    topic: Literal[\"general\", \"news\", \"finance\"] = \"general\",\n",
    "    include_raw_content: bool = False,\n",
    "):\n",
    "    \"\"\"Run a web search using Tavily API.\n",
    "    \n",
    "    Args:\n",
    "        query: The search query\n",
    "        max_results: Maximum number of search results to return\n",
    "        topic: Topic category for focused search\n",
    "        include_raw_content: Whether to include full page content\n",
    "    \"\"\"\n",
    "    tavily_client = TavilyClient(api_key=os.environ[\"TAVILY_API_KEY\"])\n",
    "    search_docs = tavily_client.search(\n",
    "        query,\n",
    "        max_results=max_results,\n",
    "        include_raw_content=include_raw_content,\n",
    "        topic=topic,\n",
    "    )\n",
    "    return search_docs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sub-Agent Configuration\n",
    "\n",
    "Deep agents excel by using specialized sub-agents for different tasks. We'll define two sub-agents:\n",
    "\n",
    "1. **Research Agent** - Conducts focused research on specific topics\n",
    "2. **Critique Agent** - Reviews and critiques research reports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Research sub-agent prompt\n",
    "sub_research_prompt = \"\"\"You are a dedicated researcher. Your job is to conduct research based on the users questions.\n",
    "\n",
    "Conduct thorough research and then reply to the user with a detailed answer to their question\n",
    "\n",
    "only your FINAL answer will be passed on to the user. They will have NO knowledge of anything except your final message, so your final report should be your final message!\"\"\"\n",
    "\n",
    "# Research sub-agent configuration\n",
    "research_sub_agent = {\n",
    "    \"name\": \"research-agent\",\n",
    "    \"description\": \"Used to research more in depth questions. Only give this researcher one topic at a time. Do not pass multiple sub questions to this researcher. Instead, you should break down a large topic into the necessary components, and then call multiple research agents in parallel, one for each sub question.\",\n",
    "    \"prompt\": sub_research_prompt,\n",
    "    \"tools\": [\"internet_search\"]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Critique sub-agent prompt\n",
    "sub_critique_prompt = \"\"\"You are a dedicated editor. You are being tasked to critique a report.\n",
    "\n",
    "You can find the report at `final_report.md`.\n",
    "\n",
    "You can find the question/topic for this report at `question.txt`.\n",
    "\n",
    "The user may ask for specific areas to critique the report in. Respond to the user with a detailed critique of the report. Things that could be improved.\n",
    "\n",
    "You can use the search tool to search for information, if that will help you critique the report\n",
    "\n",
    "Do not write to the `final_report.md` yourself.\n",
    "\n",
    "Things to check:\n",
    "- Check that each section is appropriately named\n",
    "- Check that the report is written as you would find in an essay or a textbook - it should be text heavy, do not let it just be a list of bullet points!\n",
    "- Check that the report is comprehensive. If any paragraphs or sections are short, or missing important details, point it out.\n",
    "- Check that the article covers key areas of the industry, ensures overall understanding, and does not omit important parts.\n",
    "- Check that the article deeply analyzes causes, impacts, and trends, providing valuable insights\n",
    "- Check that the article closely follows the research topic and directly answers questions\n",
    "- Check that the article has a clear structure, fluent language, and is easy to understand.\n",
    "\"\"\"\n",
    "\n",
    "# Critique sub-agent configuration\n",
    "critique_sub_agent = {\n",
    "    \"name\": \"critique-agent\",\n",
    "    \"description\": \"Used to critique the final report. Give this agent some information about how you want it to critique the report.\",\n",
    "    \"prompt\": sub_critique_prompt,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main Agent Instructions\n",
    "\n",
    "The main agent's instructions are crucial for deep reasoning. These instructions guide the agent through the research process, including how to use sub-agents, manage files, and structure reports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "research_instructions = \"\"\"You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.\n",
    "\n",
    "The first thing you should do is to write the original user question to `question.txt` so you have a record of it.\n",
    "\n",
    "Use the research-agent to conduct deep research. It will respond to your questions/topics with a detailed answer.\n",
    "\n",
    "When you think you enough information to write a final report, write it to `final_report.md`\n",
    "\n",
    "You can call the critique-agent to get a critique of the final report. After that (if needed) you can do more research and edit the `final_report.md`\n",
    "You can do this however many times you want until are you satisfied with the result.\n",
    "\n",
    "Only edit the file once at a time (if you call this tool in parallel, there may be conflicts).\n",
    "\n",
    "Here are instructions for writing the final report:\n",
    "\n",
    "<report_instructions>\n",
    "\n",
    "CRITICAL: Make sure the answer is written in the same language as the human messages! If you make a todo plan - you should note in the plan what language the report should be in so you dont forget!\n",
    "Note: the language the report should be in is the language the QUESTION is in, not the language/country that the question is ABOUT.\n",
    "\n",
    "Please create a detailed answer to the overall research brief that:\n",
    "1. Is well-organized with proper headings (# for title, ## for sections, ### for subsections)\n",
    "2. Includes specific facts and insights from the research\n",
    "3. References relevant sources using [Title](URL) format\n",
    "4. Provides a balanced, thorough analysis. Be as comprehensive as possible, and include all information that is relevant to the overall research question. People are using you for deep research and will expect detailed, comprehensive answers.\n",
    "5. Includes a \"Sources\" section at the end with all referenced links\n",
    "\n",
    "You can structure your report in a number of different ways. Here are some examples:\n",
    "\n",
    "To answer a question that asks you to compare two things, you might structure your report like this:\n",
    "1/ intro\n",
    "2/ overview of topic A\n",
    "3/ overview of topic B\n",
    "4/ comparison between A and B\n",
    "5/ conclusion\n",
    "\n",
    "To answer a question that asks you to return a list of things, you might only need a single section which is the entire list.\n",
    "1/ list of things or table of things\n",
    "Or, you could choose to make each item in the list a separate section in the report. When asked for lists, you don't need an introduction or conclusion.\n",
    "1/ item 1\n",
    "2/ item 2\n",
    "3/ item 3\n",
    "\n",
    "To answer a question that asks you to summarize a topic, give a report, or give an overview, you might structure your report like this:\n",
    "1/ overview of topic\n",
    "2/ concept 1\n",
    "3/ concept 2\n",
    "4/ concept 3\n",
    "5/ conclusion\n",
    "\n",
    "If you think you can answer the question with a single section, you can do that too!\n",
    "1/ answer\n",
    "\n",
    "REMEMBER: Section is a VERY fluid and loose concept. You can structure your report however you think is best, including in ways that are not listed above!\n",
    "Make sure that your sections are cohesive, and make sense for the reader.\n",
    "\n",
    "For each section of the report, do the following:\n",
    "- Use simple, clear language\n",
    "- Use ## for section title (Markdown format) for each section of the report\n",
    "- Do NOT ever refer to yourself as the writer of the report. This should be a professional report without any self-referential language. \n",
    "- Do not say what you are doing in the report. Just write the report without any commentary from yourself.\n",
    "- Each section should be as long as necessary to deeply answer the question with the information you have gathered. It is expected that sections will be fairly long and verbose. You are writing a deep research report, and users will expect a thorough answer.\n",
    "- Use bullet points to list out information when appropriate, but by default, write in paragraph form.\n",
    "\n",
    "REMEMBER:\n",
    "The brief and research may be in English, but you need to translate this information to the right language when writing the final answer.\n",
    "Make sure the final answer report is in the SAME language as the human messages in the message history.\n",
    "\n",
    "Format the report in clear markdown with proper structure and include source references where appropriate.\n",
    "\n",
    "<Citation Rules>\n",
    "- Assign each unique URL a single citation number in your text\n",
    "- End with ### Sources that lists each source with corresponding numbers\n",
    "- IMPORTANT: Number sources sequentially without gaps (1,2,3,4...) in the final list regardless of which sources you choose\n",
    "- Each source should be a separate line item in a list, so that in markdown it is rendered as a list.\n",
    "- Example format:\n",
    "  [1] Source Title: URL\n",
    "  [2] Source Title: URL\n",
    "- Citations are extremely important. Make sure to include these, and pay a lot of attention to getting these right. Users will often use these citations to look into more information.\n",
    "</Citation Rules>\n",
    "</report_instructions>\n",
    "\n",
    "You have access to a few tools.\n",
    "\n",
    "## `internet_search`\n",
    "\n",
    "Use this to run an internet search for a given query. You can specify the number of results, the topic, and whether raw content should be included.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the Deep Research Agent\n",
    "\n",
    "Now we'll create our deep research agent by combining all the components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.chat_models import init_chat_model\n",
    "\n",
    "model = init_chat_model(\n",
    "    model=\"openai:claude-4.0-sonnet\",  \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deep research agent created successfully!\n"
     ]
    }
   ],
   "source": [
    "# Create the deep research agent\n",
    "agent = create_deep_agent(\n",
    "    model=model,\n",
    "    tools=[internet_search],  # Available tools\n",
    "    instructions=research_instructions,  # Main agent instructions\n",
    "    subagents=[critique_sub_agent, research_sub_agent],  # Sub-agents\n",
    ").with_config({\"recursion_limit\": 1000})  # Allow deep recursion for complex tasks\n",
    "\n",
    "print(\"Deep research agent created successfully!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding the Agent Architecture\n",
    "\n",
    "Let's visualize the agent's graph structure to understand how it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the agent graph\n",
    "try:\n",
    "    from IPython.display import Image, display\n",
    "    display(Image(agent.get_graph().draw_mermaid_png()))\n",
    "except Exception as e:\n",
    "    print(f\"Could not display graph: {e}\")\n",
    "    print(\"\\nAgent graph structure created with:\")\n",
    "    print(\"- Main agent with planning capabilities\")\n",
    "    print(\"- File system tools (read, write, edit, ls)\")\n",
    "    print(\"- Sub-agent spawning capabilities\")\n",
    "    print(\"- Internet search tool\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Research Query\n",
    "\n",
    "Let's start with a research question to see how the deep agent works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Research Query: What is LangGraph and how does it work?\n",
      "\n",
      "==================================================\n",
      "\n",
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "What is LangGraph and how does it work?\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "I'll help you research LangGraph and how it works. Let me start by recording your question and creating a plan for this research.\n",
      "Tool Calls:\n",
      "  write_file (tooluse_ogcBaEGBSAyrDWxQOG1Izg)\n",
      " Call ID: tooluse_ogcBaEGBSAyrDWxQOG1Izg\n",
      "  Args:\n",
      "    file_path: question.txt\n",
      "    content: What is LangGraph and how does it work?\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_file\n",
      "\n",
      "Updated file question.txt\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_4SPfqx1iQdKFurA6S0pobQ)\n",
      " Call ID: tooluse_4SPfqx1iQdKFurA6S0pobQ\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'pending'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'pending'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'pending'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'pending'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'pending'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'pending'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Now let me start researching LangGraph systematically. I'll begin with understanding what LangGraph is.\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_9dPJhM9lTwqdZgbE9RU9Xw)\n",
      " Call ID: tooluse_9dPJhM9lTwqdZgbE9RU9Xw\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'in_progress'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'pending'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'pending'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'in_progress'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'pending'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'pending'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  task (tooluse_Rlm-iSvwSKymZIv2mvINlQ)\n",
      " Call ID: tooluse_Rlm-iSvwSKymZIv2mvINlQ\n",
      "  Args:\n",
      "    description: Research what LangGraph is - provide a comprehensive overview including its definition, purpose, what problem it solves, and its basic concept. Focus on understanding the fundamental nature of LangGraph as a framework or tool.\n",
      "    subagent_type: research-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "# LangGraph: A Comprehensive Overview\n",
      "\n",
      "## Definition and Core Concept\n",
      "\n",
      "**LangGraph** is an open-source AI agent framework developed by LangChain that provides a graph-based architecture for building, deploying, and managing complex generative AI agent workflows. At its fundamental level, LangGraph is a message-passing framework that enables the creation of modular, stateful systems where multiple AI agents can coordinate and collaborate to accomplish sophisticated tasks.\n",
      "\n",
      "Unlike traditional linear programming approaches, LangGraph models AI workflows as **directed graphs** consisting of:\n",
      "- **Nodes**: Individual components, agents, or functions that perform specific tasks\n",
      "- **Edges**: Connections that define the flow of execution and data between nodes\n",
      "- **State**: A shared memory system that persists information across the entire workflow\n",
      "\n",
      "## Purpose and Core Problems Solved\n",
      "\n",
      "### 1. **Stateful Multi-Agent Coordination**\n",
      "LangGraph addresses the challenge of building AI systems where multiple agents need to work together while maintaining context and memory across interactions. Traditional approaches struggle with coordinating multiple AI agents that need to share information and build upon each other's work.\n",
      "\n",
      "### 2. **Complex Workflow Management**\n",
      "The framework solves the problem of managing intricate AI workflows that require:\n",
      "- Cyclical execution patterns (loops and iterations)\n",
      "- Conditional branching based on AI decision-making\n",
      "- Dynamic routing where the AI determines the next step\n",
      "- Long-running processes that need to maintain state\n",
      "\n",
      "### 3. **Beyond Linear Chains**\n",
      "While traditional LangChain operates with directed acyclic graphs (DAGs) that follow a linear sequence, LangGraph explicitly supports loops, branching, and cyclical workflows. This enables true \"agentic state machines\" where an LLM can decide the next node to activate based on current conditions.\n",
      "\n",
      "### 4. **Production-Ready Agent Systems**\n",
      "LangGraph provides enterprise-grade features including:\n",
      "- Persistent state management across sessions\n",
      "- Human-in-the-loop controls and approvals\n",
      "- Real-time streaming of agent reasoning and actions\n",
      "- Reliability and controllability mechanisms\n",
      "- Built-in monitoring and debugging capabilities\n",
      "\n",
      "## Key Architectural Components\n",
      "\n",
      "### **State Management**\n",
      "- Uses TypedDict schemas or Pydantic models to define shared state\n",
      "- Implements reducer functions to manage how state updates are applied\n",
      "- Maintains context across long-running workflows\n",
      "- Enables memory persistence between different execution cycles\n",
      "\n",
      "### **Graph Structure**\n",
      "- **StateGraph**: The core graph object that defines the workflow structure\n",
      "- **Nodes**: Python functions or LangChain runnables that process data\n",
      "- **Edges**: Fixed or conditional connections that determine execution flow\n",
      "- **Compilation**: Graphs are compiled into runnable objects supporting `.invoke()`, `.stream()`, and async operations\n",
      "\n",
      "### **Multi-Agent Capabilities**\n",
      "- Supports hierarchical agent architectures\n",
      "- Enables agent handoffs and collaboration\n",
      "- Provides supervisor-subordinate patterns\n",
      "- Allows for team-based agent coordination\n",
      "\n",
      "## What Makes LangGraph Different\n",
      "\n",
      "### **Vs. Traditional LangChain**\n",
      "- **LangChain**: Best for predictable, step-by-step linear processes\n",
      "- **LangGraph**: Handles complex, iterative, and cyclical workflows with sophisticated decision-making\n",
      "\n",
      "### **Key Advantages**\n",
      "1. **Cyclical Execution**: Unlike DAGs, supports loops and iterative reasoning\n",
      "2. **Dynamic Decision Making**: AI agents can determine workflow paths in real-time\n",
      "3. **Persistent Memory**: Maintains context across multiple interactions and sessions\n",
      "4. **Modular Architecture**: Enables reusable components and flexible system design\n",
      "5. **Production Features**: Built-in streaming, monitoring, and human oversight capabilities\n",
      "\n",
      "## Use Cases and Applications\n",
      "\n",
      "LangGraph is particularly well-suited for:\n",
      "- **Complex Chatbots**: Multi-turn conversations requiring context and memory\n",
      "- **Multi-Agent Research Systems**: Teams of AI agents collaborating on analysis tasks\n",
      "- **Workflow Automation**: Business processes requiring decision points and iterations\n",
      "- **Customer Support Systems**: Sophisticated routing and escalation mechanisms\n",
      "- **Financial Analysis**: Multi-step analysis with branching logic and collaborative agents\n",
      "- **Content Creation Pipelines**: Multi-stage content development with review cycles\n",
      "\n",
      "## Fundamental Value Proposition\n",
      "\n",
      "LangGraph represents a paradigm shift from simple chain-based AI applications to sophisticated, stateful agent architectures capable of handling real-world complexity. It provides developers with the tools to build AI systems that can:\n",
      "\n",
      "- **Think iteratively** through complex problems\n",
      "- **Maintain context** across extended interactions  \n",
      "- **Coordinate multiple specialized agents** working toward common goals\n",
      "- **Handle uncertainty** through dynamic decision-making\n",
      "- **Scale to production** with enterprise-grade reliability features\n",
      "\n",
      "The framework essentially bridges the gap between simple AI chatbots and complex, production-ready AI agent systems that can handle the nuanced, multi-step reasoning required for sophisticated real-world applications.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_eKjIktKHROm3jSMP1HD_TA)\n",
      " Call ID: tooluse_eKjIktKHROm3jSMP1HD_TA\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'in_progress'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'pending'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'in_progress'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'pending'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Now let me research the technical details of how LangGraph works.\n",
      "Tool Calls:\n",
      "  task (tooluse_5M_oPpLATDmqb0HJ1Tc8yA)\n",
      " Call ID: tooluse_5M_oPpLATDmqb0HJ1Tc8yA\n",
      "  Args:\n",
      "    description: Research how LangGraph works technically - focus on the architecture, key concepts, mechanisms, implementation details, graph execution model, state management, node and edge definitions, compilation process, and execution patterns. Provide technical depth on the inner workings.\n",
      "    subagent_type: research-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "Error: BadRequestError('Error code: 400 - {\\'error\\': {\\'message\\': \\'litellm.ContextWindowExceededError: litellm.BadRequestError: BedrockException: Context Window Error - {\"message\":\"The model returned the following errors: Input is too long for requested model.\"}\\\\nmodel=claude-4.0-sonnet. context_window_fallbacks=None. fallbacks=None.\\\\n\\\\nSet \\\\\\'context_window_fallback\\\\\\' - https://docs.litellm.ai/docs/routing#fallbacks. Received Model Group=claude-4.0-sonnet\\\\nAvailable Model Group Fallbacks=None\\', \\'type\\': None, \\'param\\': None, \\'code\\': \\'400\\'}}')\n",
      " Please fix your mistakes.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Let me try with a more focused research request to avoid context window issues.\n",
      "Tool Calls:\n",
      "  task (tooluse_lBbmgV1_SCG3ftOTrPX1mQ)\n",
      " Call ID: tooluse_lBbmgV1_SCG3ftOTrPX1mQ\n",
      "  Args:\n",
      "    description: Research the technical architecture of LangGraph - specifically focus on: 1) How graphs are structured with nodes and edges, 2) The state management system and how state flows through the graph, 3) The compilation and execution process, 4) How conditional routing and loops work. Keep the response focused and technical.\n",
      "    subagent_type: research-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "Based on my comprehensive research, I can now provide you with a detailed technical analysis of LangGraph's architecture focusing on the four key areas you requested.\n",
      "\n",
      "# LangGraph Technical Architecture: A Deep Dive\n",
      "\n",
      "## 1. Graph Structure: Nodes and Edges\n",
      "\n",
      "LangGraph models agent workflows as **directed graphs** with cyclical capabilities, fundamentally different from traditional DAG-based frameworks.\n",
      "\n",
      "### Core Components:\n",
      "- **Nodes**: Python functions that encode agent logic, receiving current state as input and returning updated state\n",
      "- **Edges**: Define execution flow and routing between nodes\n",
      "- **StateGraph**: The main graph class parameterized by a user-defined state object\n",
      "\n",
      "### Node Types:\n",
      "- **Regular Nodes**: Standard Python functions (sync/async) with state as first parameter\n",
      "- **START Node**: Special virtual node representing entry point\n",
      "- **END Node**: Terminal node marking execution completion\n",
      "- **Subgraph Nodes**: Entire graphs embedded as nodes for hierarchical architectures\n",
      "\n",
      "### Edge Types:\n",
      "- **Normal Edges**: Direct connections (`graph.add_edge(\"node_a\", \"node_b\")`)\n",
      "- **Conditional Edges**: Dynamic routing based on state evaluation\n",
      "- **Entry Points**: Define starting nodes from START\n",
      "- **Conditional Entry Points**: Dynamic entry point selection\n",
      "\n",
      "### Execution Model:\n",
      "LangGraph uses a **message-passing algorithm** inspired by Google's Pregel system, executing in discrete \"super-steps\":\n",
      "- Nodes begin in `inactive` state\n",
      "- Become `active` when receiving messages on incoming edges\n",
      "- Execute function and send updates to next nodes\n",
      "- Graph terminates when all nodes are `inactive` with no messages in transit\n",
      "\n",
      "## 2. State Management System\n",
      "\n",
      "### State Schema Definition:\n",
      "State can be defined using `TypedDict` or Pydantic `BaseModel`:\n",
      "```python\n",
      "class State(TypedDict):\n",
      "    messages: Annotated[list[AnyMessage], add_messages]\n",
      "    counter: Annotated[int, operator.add]\n",
      "    data: str  # Uses default reducer (overwrite)\n",
      "```\n",
      "\n",
      "### Reducer Functions:\n",
      "**Critical for state evolution** - each state key has an independent reducer function:\n",
      "\n",
      "- **Default Reducer**: Overwrites previous values\n",
      "- **Built-in Reducers**: `operator.add` for accumulation, `add_messages` for message handling\n",
      "- **Custom Reducers**: User-defined functions for complex state logic\n",
      "\n",
      "### State Flow Mechanics:\n",
      "1. **Node Execution**: Nodes return partial state updates (not full state)\n",
      "2. **Reducer Application**: Updates applied using specified reducer functions\n",
      "3. **State Persistence**: Automatically saved after each step for resumability\n",
      "4. **Concurrent Handling**: Reducers manage multiple simultaneous updates\n",
      "\n",
      "### Advanced State Features:\n",
      "- **Multiple Schemas**: Support for input/output schemas separate from internal state\n",
      "- **Private State**: Internal node communication channels\n",
      "- **Message Serialization**: Automatic conversion between formats\n",
      "- **State Injection**: Tools can access state via `InjectedState` annotation\n",
      "\n",
      "## 3. Compilation and Execution Process\n",
      "\n",
      "### Compilation Phase:\n",
      "```python\n",
      "graph = graph_builder.compile(\n",
      "    checkpointer=memory,  # For persistence\n",
      "    interrupt_before=[\"human_node\"],  # For human-in-the-loop\n",
      "    interrupt_after=[\"validation_node\"]\n",
      ")\n",
      "```\n",
      "\n",
      "**Compilation performs**:\n",
      "- **Structure Validation**: Checks for orphaned nodes, invalid connections\n",
      "- **Runtime Configuration**: Sets up checkpointers, breakpoints, recursion limits\n",
      "- **Optimization**: Prepares execution plan and message routing\n",
      "\n",
      "### Execution Runtime:\n",
      "- **Super-step Processing**: Discrete execution cycles\n",
      "- **Parallel Execution**: Multiple nodes can execute simultaneously within same super-step\n",
      "- **State Checkpointing**: Automatic state persistence between steps\n",
      "- **Error Handling**: Graceful failure recovery with state rollback capabilities\n",
      "\n",
      "### Execution Control:\n",
      "- **Recursion Limits**: Maximum super-steps (default: 25)\n",
      "- **Interrupts**: Pause execution at specified nodes\n",
      "- **Streaming**: Real-time execution monitoring\n",
      "- **Configuration**: Runtime parameter injection\n",
      "\n",
      "## 4. Conditional Routing and Loops\n",
      "\n",
      "### Conditional Edge Implementation:\n",
      "```python\n",
      "def routing_function(state: State) -> str:\n",
      "    if state[\"condition\"]:\n",
      "        return \"node_b\"\n",
      "    return \"node_c\"\n",
      "\n",
      "graph.add_conditional_edges(\n",
      "    \"node_a\", \n",
      "    routing_function,\n",
      "    {\"node_b\": \"process_true\", \"node_c\": \"process_false\"}\n",
      ")\n",
      "```\n",
      "\n",
      "### Advanced Routing Mechanisms:\n",
      "\n",
      "#### Command Objects:\n",
      "Combine state updates with routing decisions:\n",
      "```python\n",
      "def my_node(state: State) -> Command[Literal[\"next_node\"]]:\n",
      "    return Command(\n",
      "        update={\"key\": \"value\"},\n",
      "        goto=\"next_node\"\n",
      "    )\n",
      "```\n",
      "\n",
      "#### Send Objects:\n",
      "Dynamic routing with custom state for map-reduce patterns:\n",
      "```python\n",
      "def fan_out(state: State):\n",
      "    return [Send(\"process_item\", {\"item\": item}) for item in state[\"items\"]]\n",
      "```\n",
      "\n",
      "### Loop Mechanisms:\n",
      "- **Self-loops**: Nodes can route back to themselves\n",
      "- **Conditional Loops**: Continue until condition met\n",
      "- **Bounded Loops**: Recursion limits prevent infinite execution\n",
      "- **Multi-path Loops**: Complex routing through multiple nodes\n",
      "\n",
      "### Routing Strategies:\n",
      "1. **LLM-based Routing**: Use language models for dynamic decisions\n",
      "2. **Rule-based Routing**: Deterministic conditional logic\n",
      "3. **Hybrid Routing**: Combination of LLM and rule-based approaches\n",
      "4. **Tool-based Routing**: Tools that return routing commands\n",
      "\n",
      "### Loop Control Patterns:\n",
      "- **ReAct Loops**: Reasoning-Action cycles until completion\n",
      "- **Validation Loops**: Retry until quality thresholds met\n",
      "- **Human-in-the-loop**: Pause for human intervention\n",
      "- **Multi-agent Handoffs**: Route between specialized agents\n",
      "\n",
      "This architecture enables LangGraph to handle complex, stateful workflows with sophisticated control flow while maintaining reliability and debuggability through its structured approach to state management and execution control.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_2xxe4miCS3aZCqB3whJ-Og)\n",
      " Call ID: tooluse_2xxe4miCS3aZCqB3whJ-Og\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'in_progress'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'in_progress'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'pending'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  task (tooluse_ZqFpzbUlTiyXeLsZipTxCQ)\n",
      " Call ID: tooluse_ZqFpzbUlTiyXeLsZipTxCQ\n",
      "  Args:\n",
      "    description: Research LangGraph's key features and capabilities - focus on specific features like human-in-the-loop, streaming, persistence, debugging tools, multi-agent support, and any other distinctive capabilities that make LangGraph powerful for building AI agent systems.\n",
      "    subagent_type: research-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "Based on my comprehensive research, I can provide you with a detailed analysis of LangGraph's key features and capabilities that make it a powerful framework for building AI agent systems.\n",
      "\n",
      "# LangGraph: Key Features and Capabilities for AI Agent Systems\n",
      "\n",
      "## Overview\n",
      "LangGraph is a low-level orchestration framework designed specifically for building, managing, and deploying long-running, stateful AI agents. Trusted by companies like Klarna, Replit, and Elastic, it represents a significant evolution from simple chain-based workflows to sophisticated, graph-based agent architectures capable of handling real-world complexity and production demands.\n",
      "\n",
      "## Core Distinctive Features\n",
      "\n",
      "### 1. **Graph-Based Architecture**\n",
      "- **Stateful Workflows**: Unlike traditional linear chains, LangGraph uses a graph-based approach that enables complex, cyclical workflows with branching logic\n",
      "- **Node-Based Design**: Each agent behavior is defined as a distinct node, allowing for modular and reusable components\n",
      "- **Dynamic Flow Control**: Uses algorithms or model outputs to determine the next step in execution, providing sophisticated control over workflow logic\n",
      "\n",
      "### 2. **Advanced State Management**\n",
      "- **Persistent State**: Maintains state across all steps of execution, enabling complex multi-step processes\n",
      "- **Thread-Scoped State**: Each conversation or workflow maintains its own isolated state context\n",
      "- **State Sharing**: Enables information sharing between different parts of the graph and between multiple agents\n",
      "- **Checkpointing**: Automatically saves state after each step, allowing for fault tolerance and recovery\n",
      "\n",
      "## Human-in-the-Loop Capabilities\n",
      "\n",
      "### **Comprehensive Human Intervention**\n",
      "- **Interrupt Mechanisms**: Can pause graph execution at any point to enable human review, editing, and approval\n",
      "- **Tool Call Review**: Allows humans to review, edit, and approve tool calls before execution\n",
      "- **Input Validation**: Pauses execution to validate human input before proceeding\n",
      "- **Indefinite Pausing**: Uses persistence layer to pause workflows indefinitely until human intervention is complete\n",
      "- **Resume from Checkpoint**: Can continue execution from exactly where it left off after human input\n",
      "\n",
      "### **Flexible Integration Points**\n",
      "- Human oversight can be added to specific nodes or applied globally across the workflow\n",
      "- Supports routing based on human input to determine next steps\n",
      "- Enables collaborative human-AI workflows where humans and agents work together seamlessly\n",
      "\n",
      "## Streaming Capabilities\n",
      "\n",
      "### **Real-Time Output**\n",
      "- **Live Streaming**: Supports streaming outputs as they are generated, allowing users to see results in real-time\n",
      "- **Improved User Experience**: Users can observe agent actions and reasoning as they happen\n",
      "- **Progressive Results**: Enables faster perceived response times by showing intermediate results\n",
      "- **Event-Based Updates**: Provides real-time updates on state changes and node execution\n",
      "\n",
      "### **Production-Ready Streaming**\n",
      "- Optimized for long-running applications with continuous output requirements\n",
      "- Supports both synchronous and asynchronous streaming patterns\n",
      "- Integrates seamlessly with web applications and APIs for real-time user interfaces\n",
      "\n",
      "## Persistence and Memory Management\n",
      "\n",
      "### **Short-Term Memory**\n",
      "- **Thread-Scoped Persistence**: Manages short-term memory as part of agent state, persisted through thread-scoped checkpoints\n",
      "- **Conversation Context**: Maintains context within individual conversations or workflows\n",
      "- **State Continuity**: Ensures information is retained throughout the execution of a single workflow\n",
      "\n",
      "### **Long-Term Memory**\n",
      "- **Cross-Thread Memory**: Store and recall information between different conversations and threads\n",
      "- **User Profiles**: Can maintain continuously updated profiles of users, organizations, or entities\n",
      "- **Learning from Feedback**: Agents can learn from previous interactions and adapt to user preferences\n",
      "- **InMemoryStore System**: Provides structured long-term memory management within conversational agents\n",
      "\n",
      "### **Memory Architecture**\n",
      "- **Dual Memory System**: Combines both short-term (thread-scoped) and long-term (cross-thread) memory capabilities\n",
      "- **Flexible Storage**: Supports various storage backends for different persistence requirements\n",
      "- **Memory Retrieval**: Efficient mechanisms for accessing and updating stored information\n",
      "\n",
      "## Debugging Tools and Development Environment\n",
      "\n",
      "### **LangGraph Studio - Specialized Agent IDE**\n",
      "- **Visual Graph Editor**: Provides visualization of agent graphs and workflow structures\n",
      "- **Real-Time Debugging**: Monitor graph execution in real-time with state updates\n",
      "- **Interactive Development**: Test and iterate on agent workflows directly in the IDE\n",
      "- **Node Mapping**: Visual representation of how nodes connect and data flows through the system\n",
      "\n",
      "### **Advanced Debugging Features**\n",
      "- **State Inspection**: View and modify agent state at any point during execution\n",
      "- **Thread Management**: Create, edit, and manage different conversation threads\n",
      "- **Execution History**: Track the complete history of workflow executions\n",
      "- **LangSmith Integration**: Seamless integration with LangSmith for tracing, evaluation, and prompt engineering\n",
      "\n",
      "### **Development Tools**\n",
      "- **Configuration Management**: Easy management of assistant configurations and settings\n",
      "- **API Documentation**: Built-in API documentation and testing capabilities\n",
      "- **Local Development Server**: Run and test workflows locally before deployment\n",
      "- **Error Tracking**: Comprehensive error tracking and debugging capabilities\n",
      "\n",
      "## Multi-Agent Support and Orchestration\n",
      "\n",
      "### **Hierarchical Multi-Agent Systems**\n",
      "- **Agent Coordination**: Sophisticated orchestration of multiple AI agents working together\n",
      "- **Supervisor Patterns**: Support for hierarchical agent structures with supervisor-worker relationships\n",
      "- **Agent Specialization**: Each agent can have its own prompt, LLM, tools, and custom code for specific tasks\n",
      "- **Collaborative Workflows**: Agents can collaborate on complex tasks requiring different expertise\n",
      "\n",
      "### **Multi-Agent Communication**\n",
      "- **State Sharing**: Agents can share information through the common state management system\n",
      "- **Message Passing**: Structured communication between agents\n",
      "- **Task Distribution**: Intelligent distribution of tasks among available agents\n",
      "- **Conflict Resolution**: Mechanisms for handling conflicts between agent decisions\n",
      "\n",
      "### **Swarm Intelligence**\n",
      "- **LangGraph Multi-Agent Swarm**: Specialized library for creating swarm-style multi-agent systems\n",
      "- **Collective Problem Solving**: Multiple agents working together as a cohesive unit\n",
      "- **Dynamic Agent Assignment**: Automatic assignment of agents to tasks based on capabilities and availability\n",
      "\n",
      "## Production Deployment and Scalability\n",
      "\n",
      "### **LangGraph Platform**\n",
      "- **Purpose-Built Deployment**: Specialized platform for deploying and scaling agent applications\n",
      "- **Infrastructure for Agents**: Built specifically for the unique requirements of agent workloads\n",
      "- **Opinionated APIs**: Streamlined APIs designed specifically for building agent user experiences\n",
      "- **Integrated Studio**: Development and debugging tools integrated with the deployment platform\n",
      "\n",
      "### **Enterprise-Ready Features**\n",
      "- **Fault Tolerance**: Robust error handling and recovery mechanisms\n",
      "- **Scalability**: Designed to handle enterprise-scale workloads\n",
      "- **Security**: Production-grade security features for sensitive applications\n",
      "- **Monitoring**: Comprehensive monitoring and observability tools\n",
      "\n",
      "## Additional Distinctive Capabilities\n",
      "\n",
      "### **Functional API**\n",
      "- **Traditional Programming Paradigm**: Allows developers to use familiar programming patterns\n",
      "- **Decorators**: Simple `@entrypoint` and `@task` decorators for defining workflows\n",
      "- **Standard Control Flow**: Use regular loops and conditionals to control execution flow\n",
      "- **Flexible Architecture**: Combines the power of graph-based workflows with familiar programming constructs\n",
      "\n",
      "### **Integration Ecosystem**\n",
      "- **LangChain Compatibility**: Seamless integration with the entire LangChain ecosystem\n",
      "- **Tool Integration**: Easy integration with external tools and services\n",
      "- **Model Agnostic**: Works with various LLM providers and models\n",
      "- **Extensible Architecture**: Plugin system for custom extensions and integrations\n",
      "\n",
      "### **Advanced Workflow Patterns**\n",
      "- **Conditional Routing**: Dynamic routing based on state or model outputs\n",
      "- **Parallel Execution**: Support for parallel processing of independent tasks\n",
      "- **Error Handling**: Sophisticated error handling and retry mechanisms\n",
      "- **Workflow Composition**: Ability to compose complex workflows from simpler components\n",
      "\n",
      "## Conclusion\n",
      "\n",
      "LangGraph stands out as a comprehensive framework that addresses the complex requirements of modern AI agent systems. Its combination of graph-based architecture, advanced state management, human-in-the-loop capabilities, real-time streaming, sophisticated debugging tools, and robust multi-agent support makes it uniquely positioned for building production-ready AI applications. The framework's emphasis on persistence, fault tolerance, and scalability, combined with its specialized development environment (LangGraph Studio), provides developers with the tools needed to build, debug, and deploy sophisticated AI agent systems that can handle real-world complexity and scale to enterprise requirements.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_wVxWeG5QR9q0-gSRJDI_sg)\n",
      " Call ID: tooluse_wVxWeG5QR9q0-gSRJDI_sg\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'in_progress'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'in_progress'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'pending'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  task (tooluse_twzfDGgtQzS0U2cg4I3RjA)\n",
      " Call ID: tooluse_twzfDGgtQzS0U2cg4I3RjA\n",
      "  Args:\n",
      "    description: Research specific use cases and applications of LangGraph - provide concrete examples of how companies and developers are using LangGraph, what types of applications it's best suited for, and specific industry applications or problem domains where it excels.\n",
      "    subagent_type: research-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "Based on my comprehensive research, I can provide you with detailed insights into LangGraph's specific use cases and applications across various industries and problem domains.\n",
      "\n",
      "# LangGraph: Specific Use Cases and Applications\n",
      "\n",
      "## Overview\n",
      "LangGraph is a graph-based orchestration framework for AI agents that enables the creation of sophisticated, stateful multi-agent workflows. Unlike traditional linear AI pipelines, LangGraph allows for complex decision-making loops, state persistence, and dynamic agent coordination.\n",
      "\n",
      "## Major Production Applications by Leading Companies\n",
      "\n",
      "### 1. **Customer Support at Scale**\n",
      "**Klarna's AI Assistant** represents one of the most successful LangGraph implementations:\n",
      "- **Scale**: Handles customer support for 85 million active users\n",
      "- **Performance**: Reduced customer resolution time by 80%\n",
      "- **Automation**: Automated 70% of repetitive support tasks\n",
      "- **Volume**: Processed over 2.5 million customer conversations\n",
      "- **Technology Stack**: Powered by LangGraph and LangSmith for reliability and observability\n",
      "\n",
      "### 2. **Recruitment and Talent Acquisition**\n",
      "**LinkedIn's AI Recruiter** demonstrates LangGraph's capability in complex matching scenarios:\n",
      "- **Functionality**: Streamlines hiring with conversational search and candidate matching\n",
      "- **Architecture**: Uses hierarchical agent systems for sophisticated decision-making\n",
      "- **Application**: Handles complex recruitment workflows that require multiple decision points\n",
      "\n",
      "### 3. **Software Development and Code Migration**\n",
      "**Uber's Developer Platform Team** leverages LangGraph for large-scale development tasks:\n",
      "- **Use Case**: Automated unit test generation for large-scale code migrations\n",
      "- **Architecture**: Network of specialized agents working collaboratively\n",
      "- **Impact**: Significantly reduces manual effort in code migration projects\n",
      "\n",
      "### 4. **Cybersecurity and Threat Detection**\n",
      "**Elastic's Security Platform** uses LangGraph for real-time threat analysis:\n",
      "- **Application**: Orchestrates AI agents for threat detection scenarios\n",
      "- **Workflow**: Multi-step analysis including log monitoring, anomaly identification, threat analysis, and response recommendations\n",
      "- **Advantage**: Enables complex conditional logic for security decision-making\n",
      "\n",
      "### 5. **Code Generation and Development**\n",
      "**Replit** implements LangGraph for intelligent code generation:\n",
      "- **Focus**: Advanced code generation capabilities\n",
      "- **Integration**: Seamless integration with development workflows\n",
      "\n",
      "## Key Industry Applications and Problem Domains\n",
      "\n",
      "### 1. **Multi-Agent Customer Service Systems**\n",
      "- **Best For**: Complex customer inquiries requiring multiple specialized agents\n",
      "- **Examples**: Travel booking systems, technical support, financial services\n",
      "- **Advantages**: Route queries to appropriate specialists, maintain conversation context, escalate when needed\n",
      "\n",
      "### 2. **Financial Services and Analysis**\n",
      "- **Applications**: Investment thesis development, risk assessment, financial document analysis\n",
      "- **Workflow**: Collaborative agents handling data collection, modeling, and analysis\n",
      "- **Features**: Branching logic for different analysis methodologies, state tracking for complex financial workflows\n",
      "\n",
      "### 3. **Healthcare and Medical Applications**\n",
      "**Companies like OpenRecovery and Vizient** use LangGraph for:\n",
      "- **Domain-specific copilots**: Specialized medical assistance tools\n",
      "- **Healthcare insights**: Reliable data analysis for healthcare providers\n",
      "- **Patient support**: Automated but supervised patient interaction systems\n",
      "\n",
      "### 4. **Real Estate and Property Management**\n",
      "**Rexera** demonstrates LangGraph's effectiveness in:\n",
      "- **Property search and matching**: Complex multi-criteria property recommendations\n",
      "- **Client interaction**: Sophisticated conversational interfaces for property inquiries\n",
      "- **Document processing**: Automated handling of real estate documentation\n",
      "\n",
      "### 5. **Software Development and DevOps**\n",
      "- **Code generation**: Automated code creation with quality checks\n",
      "- **Testing automation**: Intelligent test case generation and execution\n",
      "- **Migration assistance**: Large-scale codebase transformations\n",
      "\n",
      "## Core Workflow Patterns LangGraph Excels At\n",
      "\n",
      "### 1. **Human-in-the-Loop (HIL) Workflows**\n",
      "- **Approval gates**: Pause execution for human review and approval\n",
      "- **Quality control**: Human validation of AI-generated content\n",
      "- **Decision points**: Complex decisions requiring human judgment\n",
      "- **Use cases**: Legal document review, medical diagnosis assistance, financial approvals\n",
      "\n",
      "### 2. **Multi-Agent Collaboration**\n",
      "- **Specialized agents**: Different agents for different expertise areas\n",
      "- **Sequential processing**: Agents working in defined sequences\n",
      "- **Parallel processing**: Multiple agents working simultaneously\n",
      "- **Supervisor patterns**: Coordinating agent managing multiple worker agents\n",
      "\n",
      "### 3. **Complex Decision Trees**\n",
      "- **Conditional branching**: Dynamic workflow paths based on conditions\n",
      "- **State-dependent routing**: Decisions based on accumulated state\n",
      "- **Retry mechanisms**: Intelligent error handling and recovery\n",
      "- **Escalation patterns**: Automatic escalation based on complexity or confidence levels\n",
      "\n",
      "### 4. **Document Processing and Analysis**\n",
      "- **Multi-stage analysis**: Sequential processing with different analytical approaches\n",
      "- **Quality assurance**: Automated QA processes for complex documents\n",
      "- **Information extraction**: Structured data extraction from unstructured documents\n",
      "- **Compliance checking**: Automated compliance verification workflows\n",
      "\n",
      "## What Makes LangGraph Ideal for These Applications\n",
      "\n",
      "### 1. **State Persistence**\n",
      "- Maintains context across complex, multi-step workflows\n",
      "- Enables checkpointing and resumption of interrupted processes\n",
      "- Supports long-running processes that may span multiple sessions\n",
      "\n",
      "### 2. **Controllable Execution**\n",
      "- Fine-grained control over agent decision-making\n",
      "- Deterministic workflow execution with clear audit trails\n",
      "- Support for debugging and monitoring through LangSmith integration\n",
      "\n",
      "### 3. **Production Reliability**\n",
      "- Built for production environments with proper error handling\n",
      "- Observability features for monitoring agent performance\n",
      "- Scalable architecture supporting high-volume applications\n",
      "\n",
      "### 4. **Flexibility and Customization**\n",
      "- Graph-based architecture allows for complex workflow designs\n",
      "- Easy integration with existing systems and APIs\n",
      "- Support for custom agent behaviors and decision logic\n",
      "\n",
      "## Emerging Use Cases and Future Applications\n",
      "\n",
      "### 1. **Research and Analysis**\n",
      "- **Academic research**: Multi-agent research systems for literature review and analysis\n",
      "- **Market research**: Comprehensive market analysis with multiple data sources\n",
      "- **Competitive intelligence**: Automated competitive analysis workflows\n",
      "\n",
      "### 2. **Content Creation and Management**\n",
      "- **Multi-stage content creation**: Research, writing, editing, and approval workflows\n",
      "- **Content quality assurance**: Automated content review and improvement\n",
      "- **Personalization engines**: Dynamic content adaptation based on user profiles\n",
      "\n",
      "### 3. **Supply Chain and Operations**\n",
      "- **Logistics optimization**: Multi-agent systems for supply chain management\n",
      "- **Quality control**: Automated quality assurance in manufacturing\n",
      "- **Inventory management**: Intelligent inventory optimization systems\n",
      "\n",
      "LangGraph's strength lies in its ability to handle complex, stateful workflows that require multiple decision points, human oversight, and reliable execution at scale. It's particularly well-suited for enterprise applications where reliability, observability, and control are paramount, making it the framework of choice for companies building production-grade AI agent systems.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_66Z9pHM_SFKFeelFEYNpVQ)\n",
      " Call ID: tooluse_66Z9pHM_SFKFeelFEYNpVQ\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'in_progress'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'in_progress'}, {'content': 'Write comprehensive final report in English', 'status': 'pending'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  task (tooluse_WhEm1PLmQHiFTJySBFwUdA)\n",
      " Call ID: tooluse_WhEm1PLmQHiFTJySBFwUdA\n",
      "  Args:\n",
      "    description: Research LangGraph's relationship to LangChain and other tools in the ecosystem - how does it integrate with LangChain, what's the difference between them, how does it work with LangSmith, and what other tools and frameworks it integrates with or competes against.\n",
      "    subagent_type: research-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "Based on my comprehensive research, here's a detailed analysis of LangGraph's relationship to LangChain and the broader AI ecosystem:\n",
      "\n",
      "# LangGraph's Relationship to LangChain and the AI Ecosystem\n",
      "\n",
      "## LangGraph vs. LangChain: Core Relationship and Differences\n",
      "\n",
      "**LangGraph is an extension and evolution of LangChain**, not a replacement. Here are the key distinctions:\n",
      "\n",
      "### **LangChain:**\n",
      "- **Architecture**: Chain-based, sequential workflow framework\n",
      "- **Focus**: Modular LLM applications with linear chains and basic agents\n",
      "- **State Management**: Implicit, simple but less flexible\n",
      "- **Use Case**: Quick prototyping, simple LLM integrations, and straightforward workflows\n",
      "- **Workflow Type**: Primarily linear, predefined sequences\n",
      "\n",
      "### **LangGraph:**\n",
      "- **Architecture**: Graph-based, stateful workflow framework\n",
      "- **Focus**: Complex, multi-agent systems with cyclical and branching logic\n",
      "- **State Management**: Explicit, persistent state across interactions\n",
      "- **Use Case**: Production-ready agents, complex task automation, sophisticated workflows\n",
      "- **Workflow Type**: Non-linear, dynamic, with loops and conditional branching\n",
      "\n",
      "**Key Integration**: LangGraph builds on LangChain's foundation, extending its capabilities rather than replacing them. You can use LangChain components within LangGraph workflows, making them complementary tools in the same ecosystem.\n",
      "\n",
      "## LangSmith Integration\n",
      "\n",
      "**LangSmith serves as the observability and monitoring backbone** for both LangChain and LangGraph:\n",
      "\n",
      "### **Core Integration Features:**\n",
      "- **Native Tracing**: Automatic trace generation for LangGraph workflows\n",
      "- **Full Visibility**: Complete input/output tracking for each step in agent workflows\n",
      "- **Performance Monitoring**: Real-time monitoring of agent behavior and performance\n",
      "- **Debugging**: Instant debugging capabilities for complex multi-agent systems\n",
      "- **Evaluation**: LLM-as-Judge evaluators and human feedback integration\n",
      "- **Production Monitoring**: Continuous monitoring of deployed agents\n",
      "\n",
      "### **Workflow:**\n",
      "1. LangGraph applications automatically send traces to LangSmith\n",
      "2. LangSmith provides visualization of complex agent interactions\n",
      "3. Teams can debug, test, and optimize agent performance\n",
      "4. Production traces can be saved as datasets for evaluation\n",
      "\n",
      "## LangGraph Platform: Deployment and Scaling\n",
      "\n",
      "**LangGraph Platform** is the commercial deployment solution that completes the ecosystem:\n",
      "\n",
      "### **Key Features:**\n",
      "- **Purpose-built Infrastructure**: Specifically designed for long-running, stateful workflows\n",
      "- **Auto-scaling**: Automatic scaling up to 10 containers for production deployments\n",
      "- **Agent UX APIs**: Opinionated APIs for building agent-driven user experiences\n",
      "- **Developer Studio**: Integrated development environment for agent workflows\n",
      "- **Seamless Deployment**: One-click deployment from development to production\n",
      "\n",
      "## Competitors and Alternatives\n",
      "\n",
      "LangGraph competes in the multi-agent AI framework space with several notable alternatives:\n",
      "\n",
      "### **Primary Competitors:**\n",
      "\n",
      "1. **Microsoft AutoGen**\n",
      "   - **Focus**: Conversational multi-agent workflows\n",
      "   - **Strength**: Natural dialogue between agents\n",
      "   - **Use Case**: Collaborative problem-solving scenarios\n",
      "\n",
      "2. **CrewAI**\n",
      "   - **Focus**: Role-based multi-agent systems\n",
      "   - **Strength**: Hierarchical agent organization with defined roles\n",
      "   - **Use Case**: Team-based task execution\n",
      "\n",
      "3. **Microsoft Semantic Kernel**\n",
      "   - **Focus**: Lightweight SDK for AI integration\n",
      "   - **Strength**: Enterprise integration and Microsoft ecosystem compatibility\n",
      "   - **Use Case**: Enterprise applications with existing Microsoft infrastructure\n",
      "\n",
      "4. **OpenAI Agents SDK**\n",
      "   - **Focus**: OpenAI-native agent development\n",
      "   - **Strength**: Deep integration with OpenAI models and tools\n",
      "   - **Use Case**: OpenAI-centric applications\n",
      "\n",
      "### **Competitive Advantages of LangGraph:**\n",
      "- **Graph-based Architecture**: Superior for complex, non-linear workflows\n",
      "- **State Persistence**: Better memory and context management\n",
      "- **Production Readiness**: Integrated deployment and monitoring solution\n",
      "- **Ecosystem Integration**: Seamless integration with LangChain and LangSmith\n",
      "- **Flexibility**: Can integrate with other frameworks (including AutoGen and CrewAI)\n",
      "\n",
      "## Ecosystem Integrations\n",
      "\n",
      "### **Core LangChain Ecosystem:**\n",
      "- **LangChain**: Uses LangChain components and tools\n",
      "- **LangSmith**: Native observability and monitoring\n",
      "- **LangGraph Platform**: Production deployment and scaling\n",
      "\n",
      "### **External Integrations:**\n",
      "- **Model Providers**: OpenAI, Anthropic, Google, Azure, AWS, and 100+ other providers\n",
      "- **Vector Databases**: Pinecone, Weaviate, Chroma, FAISS, and others\n",
      "- **Tools and APIs**: Web search, databases, file systems, custom tools\n",
      "- **Other Agent Frameworks**: Can integrate AutoGen, CrewAI agents within LangGraph workflows\n",
      "\n",
      "### **Development Tools:**\n",
      "- **Observability**: Langfuse, Weights & Biases integration\n",
      "- **Deployment**: Docker, Kubernetes, cloud platforms\n",
      "- **Development**: Jupyter notebooks, VS Code extensions\n",
      "\n",
      "## Strategic Positioning\n",
      "\n",
      "**LangGraph represents the evolution of the LangChain ecosystem** toward production-ready, enterprise-grade agent applications. The relationship can be understood as:\n",
      "\n",
      "- **LangChain**: Foundation layer for LLM integration and basic workflows\n",
      "- **LangGraph**: Advanced orchestration layer for complex, stateful agents\n",
      "- **LangSmith**: Observability and optimization layer\n",
      "- **LangGraph Platform**: Production deployment and scaling layer\n",
      "\n",
      "This creates a comprehensive, vertically integrated solution for building, monitoring, and deploying AI agents at scale, positioning LangChain as a leader in the enterprise AI agent space while maintaining compatibility with the broader ecosystem.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_CMfFGTumSdSmQeHYs5X3_Q)\n",
      " Call ID: tooluse_CMfFGTumSdSmQeHYs5X3_Q\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'completed'}, {'content': 'Write comprehensive final report in English', 'status': 'in_progress'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'completed'}, {'content': 'Write comprehensive final report in English', 'status': 'in_progress'}, {'content': 'Get critique of final report and refine if needed', 'status': 'pending'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Now I'll write the comprehensive final report based on all the research I've gathered.\n",
      "Tool Calls:\n",
      "  write_file (tooluse_L5jTc1KYQ8yp58qpF9Wgbw)\n",
      " Call ID: tooluse_L5jTc1KYQ8yp58qpF9Wgbw\n",
      "  Args:\n",
      "    file_path: final_report.md\n",
      "    content: # LangGraph: A Comprehensive Guide to Graph-Based AI Agent Orchestration\n",
      "\n",
      "## What is LangGraph?\n",
      "\n",
      "LangGraph is an open-source AI agent framework developed by LangChain that provides a graph-based architecture for building, deploying, and managing complex generative AI agent workflows. Unlike traditional linear programming approaches, LangGraph models AI workflows as **directed graphs** consisting of nodes (individual components or agents), edges (connections defining execution flow), and a shared state system that persists information across the entire workflow.\n",
      "\n",
      "At its core, LangGraph is a message-passing framework that enables the creation of modular, stateful systems where multiple AI agents can coordinate and collaborate to accomplish sophisticated tasks. The framework represents a paradigm shift from simple chain-based AI applications to sophisticated, stateful agent architectures capable of handling real-world complexity.\n",
      "\n",
      "## Core Problems LangGraph Solves\n",
      "\n",
      "### Stateful Multi-Agent Coordination\n",
      "LangGraph addresses the challenge of building AI systems where multiple agents need to work together while maintaining context and memory across interactions. Traditional approaches struggle with coordinating multiple AI agents that need to share information and build upon each other's work.\n",
      "\n",
      "### Complex Workflow Management\n",
      "The framework excels at managing intricate AI workflows that require cyclical execution patterns (loops and iterations), conditional branching based on AI decision-making, dynamic routing where the AI determines the next step, and long-running processes that need to maintain state.\n",
      "\n",
      "### Beyond Linear Chains\n",
      "While traditional LangChain operates with directed acyclic graphs (DAGs) that follow a linear sequence, LangGraph explicitly supports loops, branching, and cyclical workflows. This enables true \"agentic state machines\" where an LLM can decide the next node to activate based on current conditions.\n",
      "\n",
      "### Production-Ready Agent Systems\n",
      "LangGraph provides enterprise-grade features including persistent state management across sessions, human-in-the-loop controls and approvals, real-time streaming of agent reasoning and actions, reliability and controllability mechanisms, and built-in monitoring and debugging capabilities.\n",
      "\n",
      "## How LangGraph Works\n",
      "\n",
      "### Graph Architecture\n",
      "LangGraph uses a **directed graph structure** with cyclical capabilities, fundamentally different from traditional DAG-based frameworks. The core components include:\n",
      "\n",
      "- **Nodes**: Python functions that encode agent logic, receiving current state as input and returning updated state\n",
      "- **Edges**: Define execution flow and routing between nodes, including normal edges (direct connections), conditional edges (dynamic routing based on state evaluation), and entry/exit points\n",
      "- **StateGraph**: The main graph class parameterized by a user-defined state object\n",
      "\n",
      "### Execution Model\n",
      "LangGraph employs a **message-passing algorithm** inspired by Google's Pregel system, executing in discrete \"super-steps\":\n",
      "1. Nodes begin in `inactive` state\n",
      "2. Become `active` when receiving messages on incoming edges\n",
      "3. Execute function and send updates to next nodes\n",
      "4. Graph terminates when all nodes are `inactive` with no messages in transit\n",
      "\n",
      "### State Management System\n",
      "State can be defined using `TypedDict` or Pydantic `BaseModel` with sophisticated reducer functions:\n",
      "\n",
      "- **Default Reducer**: Overwrites previous values\n",
      "- **Built-in Reducers**: `operator.add` for accumulation, `add_messages` for message handling\n",
      "- **Custom Reducers**: User-defined functions for complex state logic\n",
      "\n",
      "The state flow mechanics involve nodes returning partial state updates (not full state), reducer application using specified functions, automatic state persistence after each step for resumability, and concurrent handling where reducers manage multiple simultaneous updates.\n",
      "\n",
      "### Compilation and Execution Process\n",
      "The compilation phase performs structure validation, runtime configuration setup, and optimization. The execution runtime features super-step processing, parallel execution capabilities, state checkpointing, and graceful error handling with state rollback capabilities.\n",
      "\n",
      "### Conditional Routing and Loops\n",
      "LangGraph supports sophisticated routing mechanisms including:\n",
      "- **Command Objects**: Combine state updates with routing decisions\n",
      "- **Send Objects**: Dynamic routing with custom state for map-reduce patterns\n",
      "- **Loop Mechanisms**: Self-loops, conditional loops, bounded loops, and multi-path loops\n",
      "- **Routing Strategies**: LLM-based routing, rule-based routing, hybrid approaches, and tool-based routing\n",
      "\n",
      "## Key Features and Capabilities\n",
      "\n",
      "### Human-in-the-Loop Integration\n",
      "LangGraph provides comprehensive human intervention capabilities with interrupt mechanisms that can pause graph execution at any point, tool call review allowing humans to review and approve actions before execution, input validation systems, indefinite pausing using persistence layers, and resume-from-checkpoint functionality.\n",
      "\n",
      "### Real-Time Streaming\n",
      "The framework supports live streaming of outputs as they are generated, improved user experience through real-time observation of agent actions, progressive results for faster perceived response times, and event-based updates providing real-time state changes and node execution information.\n",
      "\n",
      "### Advanced Memory Management\n",
      "LangGraph implements a dual memory system:\n",
      "- **Short-Term Memory**: Thread-scoped persistence managing conversation context and state continuity\n",
      "- **Long-Term Memory**: Cross-thread memory storage, user profiles, learning from feedback, and structured long-term memory management through the InMemoryStore system\n",
      "\n",
      "### Development and Debugging Tools\n",
      "**LangGraph Studio** serves as a specialized agent IDE providing visual graph editing, real-time debugging with state updates, interactive development capabilities, and node mapping for visual workflow representation. Additional debugging features include state inspection, thread management, execution history tracking, and seamless LangSmith integration.\n",
      "\n",
      "### Multi-Agent Support\n",
      "The framework enables hierarchical multi-agent systems with agent coordination, supervisor patterns, agent specialization with custom prompts and tools, and collaborative workflows. It also supports swarm intelligence through the LangGraph Multi-Agent Swarm library for collective problem-solving and dynamic agent assignment.\n",
      "\n",
      "## Real-World Applications and Use Cases\n",
      "\n",
      "### Major Production Implementations\n",
      "\n",
      "**Klarna's AI Assistant** represents one of the most successful LangGraph implementations, handling customer support for 85 million active users, reducing resolution time by 80%, automating 70% of repetitive tasks, and processing over 2.5 million conversations.\n",
      "\n",
      "**LinkedIn's AI Recruiter** demonstrates sophisticated matching scenarios with conversational search and candidate matching using hierarchical agent systems for complex recruitment workflows.\n",
      "\n",
      "**Uber's Developer Platform Team** leverages LangGraph for automated unit test generation during large-scale code migrations, using networks of specialized agents working collaboratively.\n",
      "\n",
      "**Elastic's Security Platform** orchestrates AI agents for real-time threat detection with multi-step analysis including log monitoring, anomaly identification, threat analysis, and response recommendations.\n",
      "\n",
      "### Industry Applications\n",
      "\n",
      "LangGraph excels in several key domains:\n",
      "\n",
      "- **Customer Service Systems**: Complex inquiries requiring multiple specialized agents with routing, context maintenance, and escalation capabilities\n",
      "- **Financial Services**: Investment thesis development, risk assessment, and financial document analysis with collaborative agents and branching logic\n",
      "- **Healthcare**: Domain-specific copilots, healthcare insights, and patient support systems with automated but supervised interactions\n",
      "- **Software Development**: Code generation with quality checks, testing automation, and migration assistance for large-scale transformations\n",
      "- **Document Processing**: Multi-stage analysis, quality assurance, information extraction, and compliance checking workflows\n",
      "\n",
      "### Workflow Patterns\n",
      "LangGraph is particularly effective for human-in-the-loop workflows with approval gates and quality control, multi-agent collaboration with specialized agents and supervisor patterns, complex decision trees with conditional branching and state-dependent routing, and document processing with multi-stage analysis and compliance verification.\n",
      "\n",
      "## Relationship to LangChain and Ecosystem\n",
      "\n",
      "### LangGraph vs. LangChain\n",
      "LangGraph is an extension and evolution of LangChain, not a replacement. While LangChain focuses on chain-based, sequential workflows for quick prototyping and simple integrations, LangGraph provides graph-based, stateful workflows for production-ready agents and complex task automation. LangGraph builds on LangChain's foundation, allowing the use of LangChain components within LangGraph workflows.\n",
      "\n",
      "### Ecosystem Integration\n",
      "The complete ecosystem includes:\n",
      "- **LangChain**: Foundation layer for LLM integration and basic workflows\n",
      "- **LangGraph**: Advanced orchestration layer for complex, stateful agents\n",
      "- **LangSmith**: Observability and optimization layer with native tracing, performance monitoring, debugging capabilities, and production monitoring\n",
      "- **LangGraph Platform**: Production deployment and scaling layer with purpose-built infrastructure and auto-scaling capabilities\n",
      "\n",
      "### Competitive Landscape\n",
      "LangGraph competes with Microsoft AutoGen (conversational multi-agent workflows), CrewAI (role-based multi-agent systems), Microsoft Semantic Kernel (enterprise integration), and OpenAI Agents SDK (OpenAI-native development). LangGraph's competitive advantages include its graph-based architecture for complex workflows, superior state persistence, production readiness, ecosystem integration, and flexibility to integrate with other frameworks.\n",
      "\n",
      "## Conclusion\n",
      "\n",
      "LangGraph represents a significant advancement in AI agent orchestration, providing developers with the tools to build sophisticated, stateful agent systems that can handle real-world complexity. Its graph-based architecture, advanced state management, comprehensive human-in-the-loop capabilities, and production-ready features make it uniquely positioned for enterprise applications requiring reliability, observability, and control.\n",
      "\n",
      "The framework's success in major production deployments by companies like Klarna, LinkedIn, Uber, and Elastic demonstrates its capability to handle enterprise-scale workloads while maintaining the flexibility needed for diverse use cases. As AI agents become increasingly important in business applications, LangGraph provides the foundation for building the next generation of intelligent, collaborative AI systems.\n",
      "\n",
      "### Sources\n",
      "\n",
      "[1] LangGraph Documentation: https://langchain-ai.github.io/langgraph/\n",
      "[2] LangChain Blog - Introducing LangGraph: https://blog.langchain.dev/langgraph/\n",
      "[3] LangGraph GitHub Repository: https://github.com/langchain-ai/langgraph\n",
      "[4] LangSmith Documentation: https://docs.smith.langchain.com/\n",
      "[5] Klarna AI Assistant Case Study: https://www.klarna.com/international/press/klarna-ai-assistant-handles-two-thirds-of-customer-service-chats-in-its-first-month/\n",
      "[6] LangGraph Platform Documentation: https://langchain-ai.github.io/langgraph/cloud/\n",
      "[7] LangGraph Studio Documentation: https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/\n",
      "[8] Multi-Agent Systems with LangGraph: https://langchain-ai.github.io/langgraph/concepts/multi_agent/\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_file\n",
      "\n",
      "Updated file final_report.md\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_SsJLk0lFRo2U-hdO6reI2w)\n",
      " Call ID: tooluse_SsJLk0lFRo2U-hdO6reI2w\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'completed'}, {'content': 'Write comprehensive final report in English', 'status': 'completed'}, {'content': 'Get critique of final report and refine if needed', 'status': 'in_progress'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'completed'}, {'content': 'Write comprehensive final report in English', 'status': 'completed'}, {'content': 'Get critique of final report and refine if needed', 'status': 'in_progress'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Now let me get a critique of the final report to see if any improvements are needed.\n",
      "Tool Calls:\n",
      "  task (tooluse_l1SPl3-iRrWa5kwDDvTXXw)\n",
      " Call ID: tooluse_l1SPl3-iRrWa5kwDDvTXXw\n",
      "  Args:\n",
      "    description: Please critique the final report on LangGraph. Evaluate it for: 1) Comprehensiveness - does it cover all important aspects of what LangGraph is and how it works? 2) Clarity - is it well-organized and easy to understand? 3) Technical accuracy - are the technical details correct? 4) Structure and flow - does it have good logical progression? 5) Any missing important information or areas that could be improved. Provide specific suggestions for improvement.\n",
      "    subagent_type: critique-agent\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: task\n",
      "\n",
      "Based on my analysis of the final report and additional research, here is my comprehensive critique of the LangGraph report:\n",
      "\n",
      "## Comprehensive Critique of the LangGraph Report\n",
      "\n",
      "### 1. **Comprehensiveness - STRONG (8.5/10)**\n",
      "\n",
      "**Strengths:**\n",
      "- The report covers all major aspects of LangGraph comprehensively, including its core architecture, state management, execution model, and real-world applications\n",
      "- Excellent coverage of the relationship to the broader LangChain ecosystem\n",
      "- Strong inclusion of production use cases with specific companies (Klarna, LinkedIn, Uber, Elastic)\n",
      "- Good coverage of advanced features like human-in-the-loop integration and multi-agent support\n",
      "\n",
      "**Areas for Improvement:**\n",
      "- **Missing recent developments**: The report doesn't mention some 2024 updates, such as the ability for tools to directly modify graph state (mentioned in recent changelogs)\n",
      "- **Limited code examples**: While the report explains concepts well, it lacks concrete code snippets that would help readers understand implementation details\n",
      "- **Insufficient coverage of LangGraph Platform**: The platform is mentioned but not deeply explored as a deployment solution\n",
      "\n",
      "### 2. **Clarity and Organization - EXCELLENT (9/10)**\n",
      "\n",
      "**Strengths:**\n",
      "- Excellent logical flow from basic concepts to advanced features to real-world applications\n",
      "- Clear section headings that guide the reader through the content\n",
      "- Good use of formatting with bullet points and structured lists where appropriate\n",
      "- Technical concepts are explained in accessible language without oversimplification\n",
      "\n",
      "**Minor Areas for Improvement:**\n",
      "- Some technical sections (like the execution model) could benefit from visual diagrams or flowcharts\n",
      "- The state management section, while comprehensive, could use a simple example to illustrate the concept\n",
      "\n",
      "### 3. **Technical Accuracy - VERY GOOD (8/10)**\n",
      "\n",
      "**Strengths:**\n",
      "- Accurate description of the graph-based architecture and message-passing algorithm\n",
      "- Correct explanation of state management with reducers\n",
      "- Accurate comparison with traditional DAG-based approaches\n",
      "- Proper explanation of the Pregel-inspired execution model\n",
      "\n",
      "**Areas Needing Attention:**\n",
      "- **Missing latest features**: The report doesn't include recent 2024 updates like enhanced tool-state interaction capabilities\n",
      "- **Incomplete technical depth**: While accurate, some sections could go deeper into implementation specifics\n",
      "- **Version specificity**: The report doesn't specify which version of LangGraph it's describing\n",
      "\n",
      "### 4. **Structure and Flow - EXCELLENT (9/10)**\n",
      "\n",
      "**Strengths:**\n",
      "- Perfect logical progression: What → Why → How → Features → Applications → Ecosystem → Conclusion\n",
      "- Each section builds naturally on the previous one\n",
      "- Good balance between high-level concepts and technical details\n",
      "- Effective use of subsections to organize complex information\n",
      "\n",
      "**Suggestions:**\n",
      "- Consider adding a brief \"Getting Started\" section with a simple example\n",
      "- The conclusion could include future outlook or roadmap information\n",
      "\n",
      "### 5. **Specific Areas for Improvement**\n",
      "\n",
      "#### **Critical Missing Elements:**\n",
      "\n",
      "1. **Code Examples**: The report is entirely conceptual. Adding 2-3 simple code snippets would significantly improve understanding:\n",
      "   ```python\n",
      "   # Example of basic StateGraph definition\n",
      "   # Example of node implementation\n",
      "   # Example of conditional routing\n",
      "   ```\n",
      "\n",
      "2. **Recent Updates**: Missing 2024 developments such as:\n",
      "   - Enhanced tool-state interaction capabilities\n",
      "   - Latest workflow updates for both Python and JavaScript\n",
      "   - Recent platform improvements\n",
      "\n",
      "3. **Performance Considerations**: The report doesn't discuss:\n",
      "   - Scalability limitations\n",
      "   - Performance optimization strategies\n",
      "   - Resource requirements for different use cases\n",
      "\n",
      "#### **Content Enhancement Suggestions:**\n",
      "\n",
      "1. **Add a \"Quick Start\" Section**: Include a minimal working example that readers can follow\n",
      "2. **Expand Platform Coverage**: LangGraph Platform deserves more detailed coverage as a deployment solution\n",
      "3. **Include Limitations**: Discuss when NOT to use LangGraph and its current limitations\n",
      "4. **Add Troubleshooting**: Common issues and debugging strategies\n",
      "\n",
      "#### **Technical Depth Improvements:**\n",
      "\n",
      "1. **State Management**: Add a concrete example showing state flow through multiple nodes\n",
      "2. **Execution Model**: Include a step-by-step walkthrough of a simple graph execution\n",
      "3. **Integration Patterns**: More specific guidance on integrating with existing systems\n",
      "\n",
      "#### **Writing Style Enhancements:**\n",
      "\n",
      "1. **Balance**: While the report is appropriately text-heavy (good!), some sections could benefit from strategic use of diagrams\n",
      "2. **Examples**: Each major concept should have at least one concrete example\n",
      "3. **Practical Guidance**: More \"how-to\" information alongside the \"what-is\" explanations\n",
      "\n",
      "### **Overall Assessment: 8.5/10**\n",
      "\n",
      "This is a **very strong report** that successfully answers the question \"What is LangGraph and how does it work?\" The report demonstrates excellent understanding of the technology and provides comprehensive coverage of the topic. The writing is clear, well-organized, and appropriately detailed for the target audience.\n",
      "\n",
      "**Key Strengths:**\n",
      "- Comprehensive coverage of all major aspects\n",
      "- Excellent organization and flow\n",
      "- Clear, accessible writing style\n",
      "- Strong real-world context with production examples\n",
      "- Good balance of technical depth and readability\n",
      "\n",
      "**Priority Improvements:**\n",
      "1. Add 2-3 concrete code examples\n",
      "2. Include recent 2024 updates and features\n",
      "3. Expand coverage of performance and scalability considerations\n",
      "4. Add a practical \"getting started\" section\n",
      "\n",
      "The report successfully fulfills its primary objective and would serve as an excellent introduction to LangGraph for both technical and business audiences. With the suggested improvements, it could become an outstanding comprehensive guide.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Based on the critique, I can see that the report is strong but could benefit from some improvements. Let me make some targeted enhancements to address the key feedback points.\n",
      "Tool Calls:\n",
      "  edit_file (tooluse_rL_0s6kAT_GYY3QgMcXRjA)\n",
      " Call ID: tooluse_rL_0s6kAT_GYY3QgMcXRjA\n",
      "  Args:\n",
      "    file_path: final_report.md\n",
      "    old_string: ## How LangGraph Works\n",
      "\n",
      "### Graph Architecture\n",
      "LangGraph uses a **directed graph structure** with cyclical capabilities, fundamentally different from traditional DAG-based frameworks. The core components include:\n",
      "\n",
      "- **Nodes**: Python functions that encode agent logic, receiving current state as input and returning updated state\n",
      "- **Edges**: Define execution flow and routing between nodes, including normal edges (direct connections), conditional edges (dynamic routing based on state evaluation), and entry/exit points\n",
      "- **StateGraph**: The main graph class parameterized by a user-defined state object\n",
      "    new_string: ## How LangGraph Works\n",
      "\n",
      "### Graph Architecture\n",
      "LangGraph uses a **directed graph structure** with cyclical capabilities, fundamentally different from traditional DAG-based frameworks. The core components include:\n",
      "\n",
      "- **Nodes**: Python functions that encode agent logic, receiving current state as input and returning updated state\n",
      "- **Edges**: Define execution flow and routing between nodes, including normal edges (direct connections), conditional edges (dynamic routing based on state evaluation), and entry/exit points\n",
      "- **StateGraph**: The main graph class parameterized by a user-defined state object\n",
      "\n",
      "### Simple Example\n",
      "Here's a basic example of how LangGraph works:\n",
      "\n",
      "```python\n",
      "from typing import TypedDict\n",
      "from langgraph.graph import StateGraph, START, END\n",
      "\n",
      "# Define the state structure\n",
      "class State(TypedDict):\n",
      "    messages: list[str]\n",
      "    counter: int\n",
      "\n",
      "# Define nodes (functions that process state)\n",
      "def process_input(state: State) -> State:\n",
      "    return {\"messages\": state[\"messages\"] + [\"Processed input\"], \"counter\": state[\"counter\"] + 1}\n",
      "\n",
      "def make_decision(state: State) -> State:\n",
      "    return {\"messages\": state[\"messages\"] + [\"Decision made\"], \"counter\": state[\"counter\"] + 1}\n",
      "\n",
      "# Create and configure the graph\n",
      "graph = StateGraph(State)\n",
      "graph.add_node(\"process\", process_input)\n",
      "graph.add_node(\"decide\", make_decision)\n",
      "graph.add_edge(START, \"process\")\n",
      "graph.add_edge(\"process\", \"decide\")\n",
      "graph.add_edge(\"decide\", END)\n",
      "\n",
      "# Compile and run\n",
      "app = graph.compile()\n",
      "result = app.invoke({\"messages\": [], \"counter\": 0})\n",
      "```\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: edit_file\n",
      "\n",
      "Updated file final_report.md\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  edit_file (tooluse_Wqgs4QZySoGVnI7HPGJzCA)\n",
      " Call ID: tooluse_Wqgs4QZySoGVnI7HPGJzCA\n",
      "  Args:\n",
      "    old_string: ### Conditional Routing and Loops\n",
      "LangGraph supports sophisticated routing mechanisms including:\n",
      "- **Command Objects**: Combine state updates with routing decisions\n",
      "- **Send Objects**: Dynamic routing with custom state for map-reduce patterns\n",
      "- **Loop Mechanisms**: Self-loops, conditional loops, bounded loops, and multi-path loops\n",
      "- **Routing Strategies**: LLM-based routing, rule-based routing, hybrid approaches, and tool-based routing\n",
      "    file_path: final_report.md\n",
      "    new_string: ### Conditional Routing and Loops\n",
      "LangGraph supports sophisticated routing mechanisms including:\n",
      "- **Command Objects**: Combine state updates with routing decisions\n",
      "- **Send Objects**: Dynamic routing with custom state for map-reduce patterns\n",
      "- **Loop Mechanisms**: Self-loops, conditional loops, bounded loops, and multi-path loops\n",
      "- **Routing Strategies**: LLM-based routing, rule-based routing, hybrid approaches, and tool-based routing\n",
      "\n",
      "Here's an example of conditional routing:\n",
      "\n",
      "```python\n",
      "def routing_function(state: State) -> str:\n",
      "    if state[\"counter\"] > 5:\n",
      "        return \"end_process\"\n",
      "    return \"continue_process\"\n",
      "\n",
      "graph.add_conditional_edges(\n",
      "    \"decision_node\",\n",
      "    routing_function,\n",
      "    {\"end_process\": END, \"continue_process\": \"process_more\"}\n",
      ")\n",
      "```\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: edit_file\n",
      "\n",
      "Updated file final_report.md\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  edit_file (tooluse_aehq1KQMRiq4AaPNeO_U6w)\n",
      " Call ID: tooluse_aehq1KQMRiq4AaPNeO_U6w\n",
      "  Args:\n",
      "    old_string: ## Conclusion\n",
      "\n",
      "LangGraph represents a significant advancement in AI agent orchestration, providing developers with the tools to build sophisticated, stateful agent systems that can handle real-world complexity. Its graph-based architecture, advanced state management, comprehensive human-in-the-loop capabilities, and production-ready features make it uniquely positioned for enterprise applications requiring reliability, observability, and control.\n",
      "\n",
      "The framework's success in major production deployments by companies like Klarna, LinkedIn, Uber, and Elastic demonstrates its capability to handle enterprise-scale workloads while maintaining the flexibility needed for diverse use cases. As AI agents become increasingly important in business applications, LangGraph provides the foundation for building the next generation of intelligent, collaborative AI systems.\n",
      "    file_path: final_report.md\n",
      "    new_string: ## Performance and Scalability Considerations\n",
      "\n",
      "### When to Use LangGraph\n",
      "LangGraph is ideal for:\n",
      "- Complex workflows requiring multiple decision points and loops\n",
      "- Applications needing persistent state across interactions\n",
      "- Multi-agent systems requiring coordination\n",
      "- Production environments requiring reliability and observability\n",
      "\n",
      "### When NOT to Use LangGraph\n",
      "Consider alternatives for:\n",
      "- Simple, linear workflows (use basic LangChain instead)\n",
      "- One-off tasks without state requirements\n",
      "- Applications with strict latency requirements (graph overhead may add delay)\n",
      "- Simple chatbots without complex logic\n",
      "\n",
      "### Performance Characteristics\n",
      "- **Scalability**: Can handle enterprise-scale workloads with proper infrastructure\n",
      "- **Resource Requirements**: Higher memory usage due to state persistence\n",
      "- **Latency**: Additional overhead from graph execution and state management\n",
      "- **Throughput**: Optimized for complex workflows rather than high-frequency simple tasks\n",
      "\n",
      "## Conclusion\n",
      "\n",
      "LangGraph represents a significant advancement in AI agent orchestration, providing developers with the tools to build sophisticated, stateful agent systems that can handle real-world complexity. Its graph-based architecture, advanced state management, comprehensive human-in-the-loop capabilities, and production-ready features make it uniquely positioned for enterprise applications requiring reliability, observability, and control.\n",
      "\n",
      "The framework's success in major production deployments by companies like Klarna, LinkedIn, Uber, and Elastic demonstrates its capability to handle enterprise-scale workloads while maintaining the flexibility needed for diverse use cases. As AI agents become increasingly important in business applications, LangGraph provides the foundation for building the next generation of intelligent, collaborative AI systems.\n",
      "\n",
      "With continuous development and recent 2024 updates including enhanced tool-state interactions and improved platform capabilities, LangGraph continues to evolve as the leading framework for production-ready AI agent orchestration.\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: edit_file\n",
      "\n",
      "Updated file final_report.md\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  write_todos (tooluse_CK-7cQO_RjiNXeHN9Wce3A)\n",
      " Call ID: tooluse_CK-7cQO_RjiNXeHN9Wce3A\n",
      "  Args:\n",
      "    todos: [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'completed'}, {'content': 'Write comprehensive final report in English', 'status': 'completed'}, {'content': 'Get critique of final report and refine if needed', 'status': 'completed'}]\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "Name: write_todos\n",
      "\n",
      "Updated todo list to [{'content': 'Research what LangGraph is - definition, purpose, and overview', 'status': 'completed'}, {'content': 'Research how LangGraph works - architecture, key concepts, and mechanisms', 'status': 'completed'}, {'content': \"Research LangGraph's key features and capabilities\", 'status': 'completed'}, {'content': 'Research use cases and applications of LangGraph', 'status': 'completed'}, {'content': \"Research LangGraph's relationship to LangChain and other tools\", 'status': 'completed'}, {'content': 'Write comprehensive final report in English', 'status': 'completed'}, {'content': 'Get critique of final report and refine if needed', 'status': 'completed'}]\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Perfect! I have completed a comprehensive research report on LangGraph. Here's a summary of what I've delivered:\n",
      "\n",
      "## Research Complete ✅\n",
      "\n",
      "I've successfully researched and written a comprehensive report on **\"What is LangGraph and how does it work?\"** The final report covers:\n",
      "\n",
      "### Key Topics Covered:\n",
      "1. **What LangGraph is** - Definition, purpose, and core problems it solves\n",
      "2. **How it works** - Technical architecture, execution model, state management, and graph structure\n",
      "3. **Key features** - Human-in-the-loop, streaming, memory management, debugging tools, and multi-agent support\n",
      "4. **Real-world applications** - Production use cases from companies like Klarna, LinkedIn, Uber, and Elastic\n",
      "5. **Ecosystem relationships** - How it relates to LangChain, LangSmith, and competitive frameworks\n",
      "6. **Performance considerations** - When to use it, limitations, and scalability factors\n",
      "\n",
      "### Report Highlights:\n",
      "- **Comprehensive coverage** of LangGraph's graph-based architecture vs traditional linear chains\n",
      "- **Technical depth** on state management, execution models, and conditional routing\n",
      "- **Practical examples** with code snippets showing basic implementation\n",
      "- **Real production cases** demonstrating enterprise-scale success\n",
      "- **Clear explanations** of complex concepts in accessible language\n",
      "- **Complete ecosystem context** showing how LangGraph fits into the broader AI development landscape\n",
      "\n",
      "The report is structured as a professional technical document with proper citations and sources, making it suitable for both technical developers and business stakeholders who want to understand this important AI agent orchestration framework.\n",
      "\n",
      "You can find the complete report in `final_report.md` - it provides everything you need to understand what LangGraph is and how it works!\n"
     ]
    }
   ],
   "source": [
    "# Simple research query\n",
    "simple_query = \"What is LangGraph and how does it work?\"\n",
    "\n",
    "print(f\"Research Query: {simple_query}\")\n",
    "print(\"\\n\" + \"=\"*50 + \"\\n\")\n",
    "\n",
    "# Stream the agent's response\n",
    "for chunk in agent.stream(\n",
    "    {\"messages\": [{\"role\": \"user\", \"content\": simple_query}]},\n",
    "    stream_mode=\"values\"\n",
    "):\n",
    "    if \"messages\" in chunk:\n",
    "        chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "👆 LangSmith Trace: https://smith.langchain.com/public/465ab9f2-2fb1-48ef-bfdc-efaaade11c40/r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding Deep Agent Components\n",
    "\n",
    "Let's examine the key components that make this agent \"deep\":\n",
    "\n",
    "### 1. Planning Tool\n",
    "The agent has access to a built-in planning tool that helps it structure complex tasks into manageable steps.\n",
    "\n",
    "### 2. Sub-Agents\n",
    "- **Research Agent**: Focuses on gathering information on specific topics\n",
    "- **Critique Agent**: Reviews and improves the final report\n",
    "- **General Purpose Agent**: Default sub-agent with same capabilities as main agent\n",
    "\n",
    "### 3. File System Tools\n",
    "The agent can:\n",
    "- `read_file`: Read existing files\n",
    "- `write_file`: Create new files\n",
    "- `edit_file`: Modify existing files\n",
    "- `ls`: List files in the workspace\n",
    "\n",
    "### 4. Detailed System Prompt\n",
    "The agent comes with comprehensive instructions for deep reasoning and task execution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MCP Integration with OceanBase\n",
    "\n",
    "Let's integrate the deep agent with OceanBase MCP server for database operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install required MCP adapter\n",
    "!uv pip install -qU langchain-mcp-adapters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "from langchain_mcp_adapters.client import MultiServerMCPClient\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Demo function created. Run with: await demo_get_test_db_schema()\n"
     ]
    }
   ],
   "source": [
    "# Demo: Get table schema of \"test\" database\n",
    "async def demo_get_test_db_schema():\n",
    "    \"\"\"Demo function to get table schema of the 'test' database using OceanBase MCP\"\"\"\n",
    "    \n",
    "    async with MultiServerMCPClient({\n",
    "        \"oceanbase\": {\n",
    "            \"url\": \"http://localhost:8000/sse\", \n",
    "            \"transport\": \"sse\",\n",
    "        }\n",
    "    }) as mcp_client:\n",
    "        # Get OceanBase tools\n",
    "        oceanbase_tools = mcp_client.get_tools()\n",
    "        \n",
    "        # Create agent with OceanBase tools\n",
    "        agent = create_deep_agent(\n",
    "            model=model,\n",
    "            tools=oceanbase_tools,\n",
    "            instructions=\"\"\"You are a database expert. Help the user get the table schema for the 'test' database.\n",
    "\n",
    "Use the available OceanBase tools to:\n",
    "1. Connect to the database\n",
    "2. Get the schema information for the 'test' database\n",
    "3. List all tables and their structures\n",
    "4. Provide a comprehensive overview of the database schema\n",
    "\n",
    "Record your findings in a clear, structured format.\"\"\",\n",
    "            subagents=[],  # No sub-agents needed for this demo\n",
    "        ).with_config({\"recursion_limit\": 50})\n",
    "        \n",
    "        # Query for test database schema\n",
    "        query = \"Please get the table schema for the 'test' database. Show me all tables and their column definitions.\"\n",
    "        \n",
    "        print(f\"Demo Query: {query}\")\n",
    "        print(\"\\n\" + \"=\"*60 + \"\\n\")\n",
    "        \n",
    "        # Stream the agent's response\n",
    "        async for chunk in agent.astream(\n",
    "            {\"messages\": [{\"role\": \"user\", \"content\": query}]},\n",
    "            stream_mode=\"values\"\n",
    "        ):\n",
    "            if \"messages\" in chunk:\n",
    "                last_message = chunk[\"messages\"][-1]\n",
    "                if hasattr(last_message, 'content') and last_message.content:\n",
    "                    print(f\"Agent: {last_message.content}\")\n",
    "                    print(\"-\" * 40)\n",
    "\n",
    "# Run the demo\n",
    "print(\"Demo function created. Run with: await demo_get_test_db_schema()\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Demo Query: Please get the table schema for the 'test' database. Show me all tables and their column definitions.\n",
      "\n",
      "============================================================\n",
      "\n",
      "Agent: Please get the table schema for the 'test' database. Show me all tables and their column definitions.\n",
      "----------------------------------------\n",
      "Agent: I'll help you get the table schema for the 'test' database. Let me break this down into steps and connect to the database to retrieve the schema information.\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'pending'}, {'content': \"Connect to the 'test' database\", 'status': 'pending'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'pending'}, {'content': 'Get detailed column definitions for each table', 'status': 'pending'}, {'content': 'Format and present the complete schema information', 'status': 'pending'}]\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'in_progress'}, {'content': \"Connect to the 'test' database\", 'status': 'pending'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'pending'}, {'content': 'Get detailed column definitions for each table', 'status': 'pending'}, {'content': 'Format and present the complete schema information', 'status': 'pending'}]\n",
      "----------------------------------------\n",
      "Agent: {\n",
      "  \"host\": \"localhost\",\n",
      "  \"port\": \"2881\",\n",
      "  \"user\": \"root@test\",\n",
      "  \"password\": \"OB@lc!23\",\n",
      "  \"database\": \"test\"\n",
      "}\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'completed'}, {'content': \"Connect to the 'test' database\", 'status': 'in_progress'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'pending'}, {'content': 'Get detailed column definitions for each table', 'status': 'pending'}, {'content': 'Format and present the complete schema information', 'status': 'pending'}]\n",
      "----------------------------------------\n",
      "Agent: Now let me get the list of all tables in the 'test' database:\n",
      "----------------------------------------\n",
      "Agent: Tables in test: \n",
      "test\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'completed'}, {'content': \"Connect to the 'test' database\", 'status': 'completed'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'in_progress'}, {'content': 'Get detailed column definitions for each table', 'status': 'pending'}, {'content': 'Format and present the complete schema information', 'status': 'pending'}]\n",
      "----------------------------------------\n",
      "Agent: I can see there's one table named 'test' in the database. Let me get more detailed information about all tables using the INFORMATION_SCHEMA:\n",
      "----------------------------------------\n",
      "Agent: TABLE_NAME,TABLE_TYPE,ENGINE,TABLE_ROWS,TABLE_COMMENT\n",
      "test,BASE TABLE,InnoDB,12,\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'completed'}, {'content': \"Connect to the 'test' database\", 'status': 'completed'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'completed'}, {'content': 'Get detailed column definitions for each table', 'status': 'in_progress'}, {'content': 'Format and present the complete schema information', 'status': 'pending'}]\n",
      "----------------------------------------\n",
      "Agent: Now let me get the detailed column definitions for the 'test' table:\n",
      "----------------------------------------\n",
      "Agent: Description of this table: \n",
      "Field,Type,Null,Key,Default,Extra\n",
      "id,int(11),NO,PRI,None,auto_increment\n",
      "name,varchar(100),NO,,None,\n",
      "email,varchar(255),YES,UNI,None,\n",
      "age,int(11),YES,,None,\n",
      "created_at,timestamp,YES,,CURRENT_TIMESTAMP,\n",
      "is_active,tinyint(1),YES,,1,\n",
      "----------------------------------------\n",
      "Agent: Let me also get more detailed information from INFORMATION_SCHEMA.COLUMNS for a comprehensive view:\n",
      "----------------------------------------\n",
      "Agent: COLUMN_NAME,DATA_TYPE,IS_NULLABLE,COLUMN_DEFAULT,COLUMN_TYPE,COLUMN_KEY,EXTRA,COLUMN_COMMENT\n",
      "id,int,NO,None,int(11),PRI,auto_increment,\n",
      "name,varchar,NO,None,varchar(100),,,\n",
      "email,varchar,YES,None,varchar(255),UNI,,\n",
      "age,int,YES,None,int(11),,,\n",
      "created_at,timestamp,YES,CURRENT_TIMESTAMP,timestamp,,,\n",
      "is_active,tinyint,YES,1,tinyint(1),,,\n",
      "----------------------------------------\n",
      "Agent: Let me also check for any indexes on this table:\n",
      "----------------------------------------\n",
      "Agent: [('test', 0, 'PRIMARY', 1, 'id', 'A', None, None, None, '', 'BTREE', 'available', '', 'YES', None), ('test', 0, 'email', 1, 'email', 'A', None, None, None, 'YES', 'BTREE', 'available', '', 'YES', None)]\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'completed'}, {'content': \"Connect to the 'test' database\", 'status': 'completed'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'completed'}, {'content': 'Get detailed column definitions for each table', 'status': 'completed'}, {'content': 'Format and present the complete schema information', 'status': 'in_progress'}]\n",
      "----------------------------------------\n",
      "Agent: ## Database Schema for 'test' Database\n",
      "\n",
      "### Database Overview\n",
      "- **Database Name**: test\n",
      "- **Connection**: localhost:2881\n",
      "- **Total Tables**: 1\n",
      "\n",
      "### Table: `test`\n",
      "- **Type**: BASE TABLE\n",
      "- **Engine**: InnoDB\n",
      "- **Rows**: 12\n",
      "- **Comment**: (none)\n",
      "\n",
      "#### Column Definitions\n",
      "\n",
      "| Column Name | Data Type | Nullable | Default | Key | Extra | Description |\n",
      "|-------------|-----------|----------|---------|-----|-------|-------------|\n",
      "| `id` | int(11) | NO | None | PRIMARY | auto_increment | Primary key, auto-incrementing integer |\n",
      "| `name` | varchar(100) | NO | None | | | Required name field, max 100 characters |\n",
      "| `email` | varchar(255) | YES | None | UNIQUE | | Optional email field with unique constraint |\n",
      "| `age` | int(11) | YES | None | | | Optional age field |\n",
      "| `created_at` | timestamp | YES | CURRENT_TIMESTAMP | | | Timestamp field, defaults to current time |\n",
      "| `is_active` | tinyint(1) | YES | 1 | | | Boolean flag, defaults to 1 (true) |\n",
      "\n",
      "#### Indexes\n",
      "\n",
      "| Index Name | Type | Columns | Unique |\n",
      "|------------|------|---------|--------|\n",
      "| PRIMARY | BTREE | id | YES |\n",
      "| email | BTREE | email | YES |\n",
      "\n",
      "#### Table Structure Summary\n",
      "```sql\n",
      "CREATE TABLE `test` (\n",
      "  `id` int(11) NOT NULL AUTO_INCREMENT,\n",
      "  `name` varchar(100) NOT NULL,\n",
      "  `email` varchar(255) DEFAULT NULL,\n",
      "  `age` int(11) DEFAULT NULL,\n",
      "  `created_at` timestamp DEFAULT CURRENT_TIMESTAMP,\n",
      "  `is_active` tinyint(1) DEFAULT 1,\n",
      "  PRIMARY KEY (`id`),\n",
      "  UNIQUE KEY `email` (`email`)\n",
      ") ENGINE=InnoDB;\n",
      "```\n",
      "----------------------------------------\n",
      "Agent: Updated todo list to [{'content': 'Configure database connection to OceanBase', 'status': 'completed'}, {'content': \"Connect to the 'test' database\", 'status': 'completed'}, {'content': \"Get list of all tables in the 'test' database\", 'status': 'completed'}, {'content': 'Get detailed column definitions for each table', 'status': 'completed'}, {'content': 'Format and present the complete schema information', 'status': 'completed'}]\n",
      "----------------------------------------\n",
      "Agent: ### Key Findings:\n",
      "\n",
      "1. **Single Table Database**: The 'test' database contains only one table named 'test'\n",
      "2. **User Management Structure**: The table appears to be designed for storing user information with basic fields like name, email, age, and status\n",
      "3. **Data Integrity**: \n",
      "   - Primary key on `id` ensures unique records\n",
      "   - Unique constraint on `email` prevents duplicate email addresses\n",
      "   - Required `name` field ensures all records have identification\n",
      "4. **Audit Trail**: The `created_at` timestamp provides record creation tracking\n",
      "5. **Active Records**: The `is_active` flag allows for soft deletion or status management\n",
      "6. **Current Data**: The table currently contains 12 rows of data\n",
      "\n",
      "The schema is well-structured for a basic user management system with proper indexing and constraints in place.\n",
      "----------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Execute the demo\n",
    "await demo_get_test_db_schema()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "👆 LangSmith Trace: https://smith.langchain.com/public/87b3c7b5-1fcf-4967-99bb-3f914c55a017/r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key Takeaways - OceanBase MCP Integration\n",
    "\n",
    "This exercise demonstrated the integration of deep agents with OceanBase through MCP:\n",
    "\n",
    "1. **MCP Integration**: Successfully connected deep agents to OceanBase MCP server at `localhost:8000/sse`\n",
    "\n",
    "2. **Simplified Architecture**: Removed unnecessary sub-agents and tools, focusing only on database operations\n",
    "\n",
    "3. **Database-Specific Instructions**: Customized agent instructions for database schema analysis and querying\n",
    "\n",
    "4. **Focused Functionality**: Created a specialized agent for database operations rather than general research\n",
    "\n",
    "5. **Real-time Database Access**: Direct interaction with OceanBase through MCP protocol\n",
    "\n",
    "## Demo Results\n",
    "\n",
    "The demo shows how to:\n",
    "- Connect to OceanBase MCP server\n",
    "- Get table schema information for the 'test' database\n",
    "- Use deep agents for structured database analysis\n",
    "- Maintain workspace files for database findings\n",
    "\n",
    "## Next Steps\n",
    "\n",
    "To further explore OceanBase MCP integration with deep agents:\n",
    "\n",
    "- Expand to query multiple databases\n",
    "- Add more complex SQL analysis capabilities\n",
    "- Create database documentation workflows\n",
    "- Integrate with data visualization tools\n",
    "- Build database migration and optimization agents\n",
    "\n",
    "The combination of `deepagents` and `langchain-mcp-adapters` provides a powerful foundation for building database-focused AI agents with persistent workspace capabilities."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
